package lanqiao.真题.第13届决赛JavaB组;

import java.util.Arrays;
import java.util.Scanner;
import static java.lang.Math.hypot;

/**
 * @author 挚爱之夕
 * @version 1.0
 * @implSpec
 * 【问题描述】
 * 这天，小明在修路。
 * 他需要修理两条平行的道路A,B,两条路上面分别有n个和m个点需要维修，
 * 它们相对于道路起点的距离分别为a1,a2，...，an和b1,b2,...,bm。
 * 如图，两条路之间的距离为d且它们起点（最左端）的连线和两条路都垂直。
 * 小明的起点为道路A的起点，他需要尽可能快地遍历这些需要维修的n+m个点，
 * 他既可以沿着道路向右行走，也可以在两条道路之间的空地上随意行走。
 * 小明想知道遍历这些点的最短路程是多少。
 * 【输入格式】
 * 输入共三行，第一行为三个正整数n,m,d。
 * 第二行为n个由空格隔开的正整数a1,a2, ...，an。
 * 第三行为m个由空格隔开的正整数b1,b2,...,bm。
 * 【输出格式】
 * 一行，一个浮点数，表示答案，保留两位小数。
 * 【样例输入】
 * 2	2	2
 * 2	1
 * 1	2
 * 【样例输出】
 * 5.24
 * 【样例说明】
 * 图中红线指出了样例的最短路线，1+1+V5+1=5.24。
 * 【评测用例规模与约定】
 * 对于30%的数据，保证n+m≤10：
 * 对于100%的数据，保证n,m≤2000，d≤4×10^6^，ai,bi,≤10^6^。
 * @since 2023-06-03 17:35
 */
public class H_修路 {
}
class MainH{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int d = sc.nextInt();
        int[] a = new int[n + 1];
        int[] b = new int[m + 1];
        for (int i = 1; i <= n; i++) a[i] = sc.nextInt();
        for (int i = 1; i <= m; i++) b[i] = sc.nextInt();
        Arrays.sort(a, 1, n + 1);
        Arrays.sort(b, 1, m + 1);
        //dp[i][j][0] 经过a1-ai、b1-bi 在A路上的最短路程
        //dp[i][j][1] 顺序经过a1-ai、b1-bi 在B路上的最短路程
        double[][][] dp = new double[n + 1][m + 1][2];
        //预处理
        for (int i = 1; i <= n; ++i) {
            dp[i][0][0] = a[i];
            dp[i][0][1] = Double.POSITIVE_INFINITY;
        }

        if (m > 0) {
            dp[0][1][0] = Double.POSITIVE_INFINITY;
            dp[0][1][1] = hypot(d, b[1]);
            dp[0][0][1] = d;
        }

        for (int i = 2; i <= m; ++i) {
            dp[0][i][0] = Double.POSITIVE_INFINITY;
            dp[0][i][1] = b[i] - b[i - 1] + dp[0][i - 1][1];
        }

        for (int i = 1; i <= n; ++i){
            for (int j = 1; j <= m; ++j) {
                //A路上 ai 可以从 ai-1 或 bj 过来
                dp[i][j][0] = Math.min(dp[i - 1][j][0] + a[i] - a[i - 1], dp[i - 1][j][1] + hypot(d, a[i] - b[j]));
                //B路上 bj 可以从 bj-1 或 ai 过来
                dp[i][j][1] = Math.min(dp[i][j - 1][1] + b[j] - b[j - 1], dp[i][j - 1][0] + hypot(d, a[i] - b[j]));
            }
        }

        System.out.printf("%.2f", Math.min(dp[n][m][0], dp[n][m][1]));
    }
}